package main

import (
	"fmt"
	"learn02/src/learnMethod"
	"strings"
)

/*var age = test()*/

/*func test() int {
	b := myMath.B
	fmt.Println("test", b)
	return 99
}*/
func main() {
	//learnMethod.TestString()
	//learnMethod.TestTime()
	/*	learnMethod.ErrorTest()
		err := learnMethod.ErrorTest02(2)
		fmt.Println(err)
		fmt.Println("ccc")*/

	/*learnMethod.ArrayTest01()*/
	/*learnMethod.SliceTest01()*/

	/*learnMethod.TwoArray()*/
	//learnMethod.MapTest01()
	learnMethod.SliceOfMap()
}

/*func init() {
	fmt.Println("init....")
}*/

//更改后缀名   如果name有指定的suffix后缀 则不加 没有指定的后缀
//则加上指定的suffix后缀 如 name=zhangsan suffix=.jpg 结果为zhangsan.jpg
func makeSuffix(suffix string) func(string) string {
	return func(name string) string {
		if !strings.HasSuffix(name, suffix) {
			return name + suffix
		}
		return name
	}
}

//求1至tar的和
func sum(tar float64) {
	res := (tar + 1) * (tar / 2)
	fmt.Println("sum=", res)
}

//求1至tar的和
func sum2(tar int) {
	res := 0
	for i := 1; i <= tar; i++ {
		res += i
	}
	fmt.Println("sum=", res)
}

//求10的阶乘 递归完成
func factorial(tar int) int {
	if tar == 1 {
		return 1
	}
	return tar * factorial(tar-1)
}

//求10的阶乘 循环完成
func factorial2(tar int) int {
	res := 1
	for i := 1; i <= tar; i++ {
		res *= i
	}
	return res
}

/*
第一种解法，使用递归完成需求，fun1方法会执行10次，并且第一次执行未完毕，调用第二次执行，第二次执行
未完毕，调用第三次执行...最终，最多的时候，需要在栈内存同时开辟10块内存分别执行10个fun1方法。
第二种解法，使用for循环完成需求，fun2方法只会执行一次，最终，只需要在栈内存开辟一块内存执行fun2方法
即可。
很明显，第二种算法完成需求，占用的内存空间更小。
*/

func deferTest() {
	var n1, n2 int = 0, 0
	defer fmt.Println("ok2=", n1)
	defer fmt.Println("ok3=", n1)
	n1++
	n2++
	fmt.Println("ok1=", n1)
	n1++
	defer fmt.Println("ok4=", n2)
	n2++
}

//九九乘法表
func multiplication() {
	for i := 1; i <= 9; i++ {
		for j := 1; j <= i; j++ {
			fmt.Printf("%d * %d =%d\t", i, j, i*j)
		}
		fmt.Println()
	}
}
